{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp models.softs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "#| hide\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| hide\n",
    "from fastcore.test import test_eq\n",
    "from nbdev.showdoc import show_doc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SOFTS\n",
    "\n",
    "SOFTS (Series-cOre Fused Time Series) incorporates the novel STar Aggregate-Dispatch (STAD) module. Instead of leearning channel interactions through a distributed architecture, like attention, the STAD module employs a centralized strategy where series are aggregated to form a global core representation, while maintaning linear complexity.\n",
    "\n",
    "**References**\n",
    "- [Lu Han, Xu-Yang Chen, Han-Jia Ye, De-Chuan Zhan. \"SOFTS: Efficient Multivariate Time Series Forecasting with Series-Core Fusion\"](https://arxiv.org/pdf/2404.14197)\n",
    "\n",
    "![Figure 1. Architecture of SOFTS.](imgs_models/softs_architecture.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from neuralforecast.losses.pytorch import MAE\n",
    "from neuralforecast.common._base_multivariate import BaseMultivariate\n",
    "from neuralforecast.common._modules import TransEncoder, TransEncoderLayer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Auxiliary functions\n",
    "### 1.1 Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| exporti\n",
    "\n",
    "class DataEmbedding_inverted(nn.Module):\n",
    "    def __init__(self, c_in, d_model, dropout=0.1):\n",
    "        super(DataEmbedding_inverted, self).__init__()\n",
    "        self.value_embedding = nn.Linear(c_in, d_model)\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "    def forward(self, x, x_mark):\n",
    "        x = x.permute(0, 2, 1)\n",
    "        # x: [Batch Variate Time]\n",
    "        if x_mark is None:\n",
    "            x = self.value_embedding(x)\n",
    "        else:\n",
    "            # the potential to take covariates (e.g. timestamps) as tokens\n",
    "            x = self.value_embedding(torch.cat([x, x_mark.permute(0, 2, 1)], 1))\n",
    "        # x: [Batch Variate d_model]\n",
    "        return self.dropout(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 STAD (STar Aggregate Dispatch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| exporti\n",
    "\n",
    "class STAD(nn.Module):\n",
    "    def __init__(self, d_series, d_core):\n",
    "        super(STAD, self).__init__()\n",
    "        \"\"\"\n",
    "        STar Aggregate Dispatch Module\n",
    "        \"\"\"\n",
    "\n",
    "        self.gen1 = nn.Linear(d_series, d_series)\n",
    "        self.gen2 = nn.Linear(d_series, d_core)\n",
    "        self.gen3 = nn.Linear(d_series + d_core, d_series)\n",
    "        self.gen4 = nn.Linear(d_series, d_series)\n",
    "\n",
    "    def forward(self, input, *args, **kwargs):\n",
    "        batch_size, channels, d_series = input.shape\n",
    "\n",
    "        # set FFN\n",
    "        combined_mean = F.gelu(self.gen1(input))\n",
    "        combined_mean = self.gen2(combined_mean)\n",
    "\n",
    "        # stochastic pooling\n",
    "        if self.training:\n",
    "            ratio = F.softmax(combined_mean, dim=1)\n",
    "            ratio = ratio.permute(0, 2, 1)\n",
    "            ratio = ratio.reshape(-1, channels)\n",
    "            indices = torch.multinomial(ratio, 1)\n",
    "            indices = indices.view(batch_size, -1, 1).permute(0, 2, 1)\n",
    "            combined_mean = torch.gather(combined_mean, 1, indices)\n",
    "            combined_mean = combined_mean.repeat(1, channels, 1)\n",
    "        else:\n",
    "            weight = F.softmax(combined_mean, dim=1)\n",
    "            combined_mean = torch.sum(combined_mean * weight, dim=1, keepdim=True).repeat(1, channels, 1)\n",
    "\n",
    "        # mlp fusion\n",
    "        combined_mean_cat = torch.cat([input, combined_mean], -1)\n",
    "        combined_mean_cat = F.gelu(self.gen3(combined_mean_cat))\n",
    "        combined_mean_cat = self.gen4(combined_mean_cat)\n",
    "        output = combined_mean_cat\n",
    "\n",
    "        return output, None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "\n",
    "class SOFTS(BaseMultivariate):\n",
    "\n",
    "    \"\"\" SOFTS\n",
    "    \n",
    "    **Parameters:**<br>\n",
    "    `h`: int, Forecast horizon. <br>\n",
    "    `input_size`: int, autorregresive inputs size, y=[1,2,3,4] input_size=2 -> y_[t-2:t]=[1,2].<br>\n",
    "    `n_series`: int, number of time-series.<br>\n",
    "    `futr_exog_list`: str list, future exogenous columns.<br>\n",
    "    `hist_exog_list`: str list, historic exogenous columns.<br>\n",
    "    `stat_exog_list`: str list, static exogenous columns.<br>\n",
    "    `hidden_size`: int, dimension of the model.<br>\n",
    "    `d_core`: int, dimension of core in STAD.<br>\n",
    "    `e_layers`: int, number of encoder layers.<br>\n",
    "    `d_ff`: int, dimension of fully-connected layer.<br>\n",
    "    `dropout`: float, dropout rate.<br>\n",
    "    `use_norm`: bool, whether to normalize or not.<br>\n",
    "    `loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
    "    `valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
    "    `max_steps`: int=1000, maximum number of training steps.<br>\n",
    "    `learning_rate`: float=1e-3, Learning rate between (0, 1).<br>\n",
    "    `num_lr_decays`: int=-1, Number of learning rate decays, evenly distributed across max_steps.<br>\n",
    "    `early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.<br>\n",
    "    `val_check_steps`: int=100, Number of training steps between every validation loss check.<br>\n",
    "    `batch_size`: int=32, number of different series in each batch.<br>\n",
    "    `step_size`: int=1, step size between each window of temporal data.<br>\n",
    "    `scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).<br>\n",
    "    `random_seed`: int=1, random_seed for pytorch initializer and numpy generators.<br>\n",
    "    `num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.<br>\n",
    "    `drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.<br>\n",
    "    `alias`: str, optional,  Custom name of the model.<br>\n",
    "    `optimizer`: Subclass of 'torch.optim.Optimizer', optional, user specified optimizer instead of the default choice (Adam).<br>\n",
    "    `optimizer_kwargs`: dict, optional, list of parameters used by the user specified `optimizer`.<br>\n",
    "    `lr_scheduler`: Subclass of 'torch.optim.lr_scheduler.LRScheduler', optional, user specified lr_scheduler instead of the default choice (StepLR).<br>\n",
    "    `lr_scheduler_kwargs`: dict, optional, list of parameters used by the user specified `lr_scheduler`.<br>\n",
    "    `**trainer_kwargs`: int,  keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).<br>\n",
    "    \n",
    "    **References**<br>\n",
    "    [Lu Han, Xu-Yang Chen, Han-Jia Ye, De-Chuan Zhan. \"SOFTS: Efficient Multivariate Time Series Forecasting with Series-Core Fusion\"](https://arxiv.org/pdf/2404.14197)\n",
    "    \"\"\"\n",
    "\n",
    "    # Class attributes\n",
    "    SAMPLING_TYPE = 'multivariate'\n",
    "    EXOGENOUS_FUTR = False\n",
    "    EXOGENOUS_HIST = False\n",
    "    EXOGENOUS_STAT = False\n",
    "\n",
    "    def __init__(self,\n",
    "                 h,\n",
    "                 input_size,\n",
    "                 n_series,\n",
    "                 futr_exog_list = None,\n",
    "                 hist_exog_list = None,\n",
    "                 stat_exog_list = None,\n",
    "                 hidden_size: int = 512,\n",
    "                 d_core: int = 512,\n",
    "                 e_layers: int = 2,\n",
    "                 d_ff: int = 2048,\n",
    "                 dropout: float = 0.1,\n",
    "                 use_norm: bool = True,\n",
    "                 loss = MAE(),\n",
    "                 valid_loss = None,\n",
    "                 max_steps: int = 1000,\n",
    "                 learning_rate: float = 1e-3,\n",
    "                 num_lr_decays: int = -1,\n",
    "                 early_stop_patience_steps: int =-1,\n",
    "                 val_check_steps: int = 100,\n",
    "                 batch_size: int = 32,\n",
    "                 step_size: int = 1,\n",
    "                 scaler_type: str = 'identity',\n",
    "                 random_seed: int = 1,\n",
    "                 num_workers_loader: int = 0,\n",
    "                 drop_last_loader: bool = False,\n",
    "                 optimizer = None,\n",
    "                 optimizer_kwargs = None,\n",
    "                 lr_scheduler = None,\n",
    "                 lr_scheduler_kwargs = None,            \n",
    "                 **trainer_kwargs):\n",
    "        \n",
    "        super(SOFTS, self).__init__(h=h,\n",
    "                                    input_size=input_size,\n",
    "                                    n_series=n_series,\n",
    "                                    stat_exog_list = None,\n",
    "                                    futr_exog_list = None,\n",
    "                                    hist_exog_list = None,\n",
    "                                    loss=loss,\n",
    "                                    valid_loss=valid_loss,\n",
    "                                    max_steps=max_steps,\n",
    "                                    learning_rate=learning_rate,\n",
    "                                    num_lr_decays=num_lr_decays,\n",
    "                                    early_stop_patience_steps=early_stop_patience_steps,\n",
    "                                    val_check_steps=val_check_steps,\n",
    "                                    batch_size=batch_size,\n",
    "                                    step_size=step_size,\n",
    "                                    scaler_type=scaler_type,\n",
    "                                    random_seed=random_seed,\n",
    "                                    num_workers_loader=num_workers_loader,\n",
    "                                    drop_last_loader=drop_last_loader,\n",
    "                                    optimizer=optimizer,\n",
    "                                    optimizer_kwargs=optimizer_kwargs,\n",
    "                                    lr_scheduler=lr_scheduler,\n",
    "                                    lr_scheduler_kwargs=lr_scheduler_kwargs,\n",
    "                                    **trainer_kwargs)\n",
    "        \n",
    "        self.h = h\n",
    "        self.enc_in = n_series\n",
    "        self.dec_in = n_series\n",
    "        self.c_out = n_series\n",
    "        self.use_norm = use_norm\n",
    "\n",
    "        # Architecture\n",
    "        self.enc_embedding = DataEmbedding_inverted(input_size, \n",
    "                                                    hidden_size, \n",
    "                                                    dropout)\n",
    "        \n",
    "        self.encoder = TransEncoder(\n",
    "            [\n",
    "                TransEncoderLayer(\n",
    "                    STAD(hidden_size, d_core),\n",
    "                    hidden_size,\n",
    "                    d_ff,\n",
    "                    dropout=dropout,\n",
    "                    activation=F.gelu\n",
    "                ) for l in range(e_layers)\n",
    "            ]\n",
    "        )\n",
    "\n",
    "        self.projection = nn.Linear(hidden_size, self.h, bias=True)\n",
    "\n",
    "    def forecast(self, x_enc):\n",
    "        # Normalization from Non-stationary Transformer\n",
    "        if self.use_norm:\n",
    "            means = x_enc.mean(1, keepdim=True).detach()\n",
    "            x_enc = x_enc - means\n",
    "            stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5)\n",
    "            x_enc /= stdev\n",
    "\n",
    "        _, _, N = x_enc.shape\n",
    "        enc_out = self.enc_embedding(x_enc, None)\n",
    "        enc_out, attns = self.encoder(enc_out, attn_mask=None)\n",
    "        dec_out = self.projection(enc_out).permute(0, 2, 1)[:, :, :N]\n",
    "\n",
    "        # De-Normalization from Non-stationary Transformer\n",
    "        if self.use_norm:\n",
    "            dec_out = dec_out * (stdev[:, 0, :].unsqueeze(1).repeat(1, self.h, 1))\n",
    "            dec_out = dec_out + (means[:, 0, :].unsqueeze(1).repeat(1, self.h, 1))\n",
    "        return dec_out\n",
    "    \n",
    "    def forward(self, windows_batch):\n",
    "        insample_y = windows_batch['insample_y']\n",
    "\n",
    "        y_pred = self.forecast(insample_y)\n",
    "        y_pred = y_pred[:, -self.h:, :]\n",
    "        y_pred = self.loss.domain_map(y_pred)\n",
    "\n",
    "        # domain_map might have squeezed the last dimension in case n_series == 1\n",
    "        if y_pred.ndim == 2:\n",
    "            return y_pred.unsqueeze(-1)\n",
    "        else:\n",
    "            return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "### SOFTS\n",
       "\n",
       ">      SOFTS (h, input_size, n_series, futr_exog_list=None, hist_exog_list=None,\n",
       ">             stat_exog_list=None, hidden_size:int=512, d_core:int=512,\n",
       ">             e_layers:int=2, d_ff:int=2048, dropout:float=0.1,\n",
       ">             use_norm:bool=True, loss=MAE(), valid_loss=None,\n",
       ">             max_steps:int=1000, learning_rate:float=0.001,\n",
       ">             num_lr_decays:int=-1, early_stop_patience_steps:int=-1,\n",
       ">             val_check_steps:int=100, batch_size:int=32, step_size:int=1,\n",
       ">             scaler_type:str='identity', random_seed:int=1,\n",
       ">             num_workers_loader:int=0, drop_last_loader:bool=False,\n",
       ">             optimizer=None, optimizer_kwargs=None, lr_scheduler=None,\n",
       ">             lr_scheduler_kwargs=None, **trainer_kwargs)\n",
       "\n",
       "SOFTS\n",
       "\n",
       "**Parameters:**<br>\n",
       "`h`: int, Forecast horizon. <br>\n",
       "`input_size`: int, autorregresive inputs size, y=[1,2,3,4] input_size=2 -> y_[t-2:t]=[1,2].<br>\n",
       "`n_series`: int, number of time-series.<br>\n",
       "`futr_exog_list`: str list, future exogenous columns.<br>\n",
       "`hist_exog_list`: str list, historic exogenous columns.<br>\n",
       "`stat_exog_list`: str list, static exogenous columns.<br>\n",
       "`hidden_size`: int, dimension of the model.<br>\n",
       "`d_core`: int, dimension of core in STAD.<br>\n",
       "`e_layers`: int, number of encoder layers.<br>\n",
       "`d_ff`: int, dimension of fully-connected layer.<br>\n",
       "`dropout`: float, dropout rate.<br>\n",
       "`use_norm`: bool, whether to normalize or not.<br>\n",
       "`loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
       "`valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
       "`max_steps`: int=1000, maximum number of training steps.<br>\n",
       "`learning_rate`: float=1e-3, Learning rate between (0, 1).<br>\n",
       "`num_lr_decays`: int=-1, Number of learning rate decays, evenly distributed across max_steps.<br>\n",
       "`early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.<br>\n",
       "`val_check_steps`: int=100, Number of training steps between every validation loss check.<br>\n",
       "`batch_size`: int=32, number of different series in each batch.<br>\n",
       "`step_size`: int=1, step size between each window of temporal data.<br>\n",
       "`scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).<br>\n",
       "`random_seed`: int=1, random_seed for pytorch initializer and numpy generators.<br>\n",
       "`num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.<br>\n",
       "`drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.<br>\n",
       "`alias`: str, optional,  Custom name of the model.<br>\n",
       "`optimizer`: Subclass of 'torch.optim.Optimizer', optional, user specified optimizer instead of the default choice (Adam).<br>\n",
       "`optimizer_kwargs`: dict, optional, list of parameters used by the user specified `optimizer`.<br>\n",
       "`lr_scheduler`: Subclass of 'torch.optim.lr_scheduler.LRScheduler', optional, user specified lr_scheduler instead of the default choice (StepLR).<br>\n",
       "`lr_scheduler_kwargs`: dict, optional, list of parameters used by the user specified `lr_scheduler`.<br>\n",
       "`**trainer_kwargs`: int,  keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).<br>\n",
       "\n",
       "**References**<br>\n",
       "[Lu Han, Xu-Yang Chen, Han-Jia Ye, De-Chuan Zhan. \"SOFTS: Efficient Multivariate Time Series Forecasting with Series-Core Fusion\"](https://arxiv.org/pdf/2404.14197)"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "### SOFTS\n",
       "\n",
       ">      SOFTS (h, input_size, n_series, futr_exog_list=None, hist_exog_list=None,\n",
       ">             stat_exog_list=None, hidden_size:int=512, d_core:int=512,\n",
       ">             e_layers:int=2, d_ff:int=2048, dropout:float=0.1,\n",
       ">             use_norm:bool=True, loss=MAE(), valid_loss=None,\n",
       ">             max_steps:int=1000, learning_rate:float=0.001,\n",
       ">             num_lr_decays:int=-1, early_stop_patience_steps:int=-1,\n",
       ">             val_check_steps:int=100, batch_size:int=32, step_size:int=1,\n",
       ">             scaler_type:str='identity', random_seed:int=1,\n",
       ">             num_workers_loader:int=0, drop_last_loader:bool=False,\n",
       ">             optimizer=None, optimizer_kwargs=None, lr_scheduler=None,\n",
       ">             lr_scheduler_kwargs=None, **trainer_kwargs)\n",
       "\n",
       "SOFTS\n",
       "\n",
       "**Parameters:**<br>\n",
       "`h`: int, Forecast horizon. <br>\n",
       "`input_size`: int, autorregresive inputs size, y=[1,2,3,4] input_size=2 -> y_[t-2:t]=[1,2].<br>\n",
       "`n_series`: int, number of time-series.<br>\n",
       "`futr_exog_list`: str list, future exogenous columns.<br>\n",
       "`hist_exog_list`: str list, historic exogenous columns.<br>\n",
       "`stat_exog_list`: str list, static exogenous columns.<br>\n",
       "`hidden_size`: int, dimension of the model.<br>\n",
       "`d_core`: int, dimension of core in STAD.<br>\n",
       "`e_layers`: int, number of encoder layers.<br>\n",
       "`d_ff`: int, dimension of fully-connected layer.<br>\n",
       "`dropout`: float, dropout rate.<br>\n",
       "`use_norm`: bool, whether to normalize or not.<br>\n",
       "`loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
       "`valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).<br>\n",
       "`max_steps`: int=1000, maximum number of training steps.<br>\n",
       "`learning_rate`: float=1e-3, Learning rate between (0, 1).<br>\n",
       "`num_lr_decays`: int=-1, Number of learning rate decays, evenly distributed across max_steps.<br>\n",
       "`early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.<br>\n",
       "`val_check_steps`: int=100, Number of training steps between every validation loss check.<br>\n",
       "`batch_size`: int=32, number of different series in each batch.<br>\n",
       "`step_size`: int=1, step size between each window of temporal data.<br>\n",
       "`scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).<br>\n",
       "`random_seed`: int=1, random_seed for pytorch initializer and numpy generators.<br>\n",
       "`num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.<br>\n",
       "`drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.<br>\n",
       "`alias`: str, optional,  Custom name of the model.<br>\n",
       "`optimizer`: Subclass of 'torch.optim.Optimizer', optional, user specified optimizer instead of the default choice (Adam).<br>\n",
       "`optimizer_kwargs`: dict, optional, list of parameters used by the user specified `optimizer`.<br>\n",
       "`lr_scheduler`: Subclass of 'torch.optim.lr_scheduler.LRScheduler', optional, user specified lr_scheduler instead of the default choice (StepLR).<br>\n",
       "`lr_scheduler_kwargs`: dict, optional, list of parameters used by the user specified `lr_scheduler`.<br>\n",
       "`**trainer_kwargs`: int,  keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).<br>\n",
       "\n",
       "**References**<br>\n",
       "[Lu Han, Xu-Yang Chen, Han-Jia Ye, De-Chuan Zhan. \"SOFTS: Efficient Multivariate Time Series Forecasting with Series-Core Fusion\"](https://arxiv.org/pdf/2404.14197)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(SOFTS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "### SOFTS.fit\n",
       "\n",
       ">      SOFTS.fit (dataset, val_size=0, test_size=0, random_seed=None,\n",
       ">                 distributed_config=None)\n",
       "\n",
       "Fit.\n",
       "\n",
       "The `fit` method, optimizes the neural network's weights using the\n",
       "initialization parameters (`learning_rate`, `windows_batch_size`, ...)\n",
       "and the `loss` function as defined during the initialization.\n",
       "Within `fit` we use a PyTorch Lightning `Trainer` that\n",
       "inherits the initialization's `self.trainer_kwargs`, to customize\n",
       "its inputs, see [PL's trainer arguments](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).\n",
       "\n",
       "The method is designed to be compatible with SKLearn-like classes\n",
       "and in particular to be compatible with the StatsForecast library.\n",
       "\n",
       "By default the `model` is not saving training checkpoints to protect\n",
       "disk memory, to get them change `enable_checkpointing=True` in `__init__`.\n",
       "\n",
       "**Parameters:**<br>\n",
       "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br>\n",
       "`val_size`: int, validation size for temporal cross-validation.<br>\n",
       "`test_size`: int, test size for temporal cross-validation.<br>"
      ],
      "text/plain": [
       "---\n",
       "\n",
       "### SOFTS.fit\n",
       "\n",
       ">      SOFTS.fit (dataset, val_size=0, test_size=0, random_seed=None,\n",
       ">                 distributed_config=None)\n",
       "\n",
       "Fit.\n",
       "\n",
       "The `fit` method, optimizes the neural network's weights using the\n",
       "initialization parameters (`learning_rate`, `windows_batch_size`, ...)\n",
       "and the `loss` function as defined during the initialization.\n",
       "Within `fit` we use a PyTorch Lightning `Trainer` that\n",
       "inherits the initialization's `self.trainer_kwargs`, to customize\n",
       "its inputs, see [PL's trainer arguments](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).\n",
       "\n",
       "The method is designed to be compatible with SKLearn-like classes\n",
       "and in particular to be compatible with the StatsForecast library.\n",
       "\n",
       "By default the `model` is not saving training checkpoints to protect\n",
       "disk memory, to get them change `enable_checkpointing=True` in `__init__`.\n",
       "\n",
       "**Parameters:**<br>\n",
       "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br>\n",
       "`val_size`: int, validation size for temporal cross-validation.<br>\n",
       "`test_size`: int, test size for temporal cross-validation.<br>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(SOFTS.fit, name='SOFTS.fit')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "---\n",
       "\n",
       "### SOFTS.predict\n",
       "\n",
       ">      SOFTS.predict (dataset, test_size=None, step_size=1, random_seed=None,\n",
       ">                     **data_module_kwargs)\n",
       "\n",
       "Predict.\n",
       "\n",
       "Neural network prediction with PL's `Trainer` execution of `predict_step`.\n",
       "\n",
       "**Parameters:**<br>\n",
       "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br>\n",
       "`test_size`: int=None, test size for temporal cross-validation.<br>\n",
       "`step_size`: int=1, Step size between each window.<br>\n",
       "`**data_module_kwargs`: PL's TimeSeriesDataModule args, see [documentation](https://pytorch-lightning.readthedocs.io/en/1.6.1/extensions/datamodules.html#using-a-datamodule)."
      ],
      "text/plain": [
       "---\n",
       "\n",
       "### SOFTS.predict\n",
       "\n",
       ">      SOFTS.predict (dataset, test_size=None, step_size=1, random_seed=None,\n",
       ">                     **data_module_kwargs)\n",
       "\n",
       "Predict.\n",
       "\n",
       "Neural network prediction with PL's `Trainer` execution of `predict_step`.\n",
       "\n",
       "**Parameters:**<br>\n",
       "`dataset`: NeuralForecast's `TimeSeriesDataset`, see [documentation](https://nixtla.github.io/neuralforecast/tsdataset.html).<br>\n",
       "`test_size`: int=None, test size for temporal cross-validation.<br>\n",
       "`step_size`: int=1, Step size between each window.<br>\n",
       "`**data_module_kwargs`: PL's TimeSeriesDataModule args, see [documentation](https://pytorch-lightning.readthedocs.io/en/1.6.1/extensions/datamodules.html#using-a-datamodule)."
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show_doc(SOFTS.predict, name='SOFTS.predict')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Usage example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| eval: false\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pytorch_lightning as pl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from neuralforecast import NeuralForecast\n",
    "from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic\n",
    "from neuralforecast.losses.pytorch import MSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Seed set to 1\n",
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "  | Name          | Type                   | Params\n",
      "---------------------------------------------------------\n",
      "0 | loss          | MSE                    | 0     \n",
      "1 | valid_loss    | MAE                    | 0     \n",
      "2 | padder        | ConstantPad1d          | 0     \n",
      "3 | scaler        | TemporalNorm           | 0     \n",
      "4 | enc_embedding | DataEmbedding_inverted | 6.4 K \n",
      "5 | encoder       | TransEncoder           | 725 K \n",
      "6 | projection    | Linear                 | 3.1 K \n",
      "---------------------------------------------------------\n",
      "735 K     Trainable params\n",
      "0         Non-trainable params\n",
      "735 K     Total params\n",
      "2.940     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6f14a500708141f8b80fc07c595537df",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b67e78ddc8c8427e9f57f9cf7fcfd477",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7db20663367847148d145112e9b59a7c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "910140121c9042448c8a1a595318b24d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "743a12147c2e4d8baf977b066db3e3d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2a7a43f75ef142a8b3e6c1da4cd25e7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Trainer already configured with model summary callbacks: [<class 'pytorch_lightning.callbacks.model_summary.ModelSummary'>]. Skipping setting a default `ModelSummary` callback.\n",
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "04596f4e25f84772b40d44eb76d2dfd3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/marcopeix/miniconda3/envs/neuralforecast/lib/python3.10/site-packages/neuralforecast/core.py:201: FutureWarning: In a future version the predictions will have the id as a column. You can set the `NIXTLA_ID_AS_COL` environment variable to adopt the new behavior and to suppress this warning.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "#| eval: false\n",
    "\n",
    "Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 132 train\n",
    "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n",
    "\n",
    "model = SOFTS(h=12,\n",
    "              input_size=24,\n",
    "              n_series=2,\n",
    "              hidden_size=256,\n",
    "              d_core=256,\n",
    "              e_layers=2,\n",
    "              d_ff=64,\n",
    "              dropout=0.1,\n",
    "              use_norm=True,\n",
    "              loss=MSE(),\n",
    "              valid_loss=MAE(),\n",
    "              early_stop_patience_steps=3,\n",
    "              batch_size=32)\n",
    "\n",
    "fcst = NeuralForecast(models=[model], freq='M')\n",
    "fcst.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)\n",
    "forecasts = fcst.predict(futr_df=Y_test_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#| eval: false\n",
    "\n",
    "# Plot predictions\n",
    "fig, ax = plt.subplots(1, 1, figsize = (20, 7))\n",
    "Y_hat_df = forecasts.reset_index(drop=False).drop(columns=['unique_id','ds'])\n",
    "plot_df = pd.concat([Y_test_df, Y_hat_df], axis=1)\n",
    "plot_df = pd.concat([Y_train_df, plot_df])\n",
    "\n",
    "plot_df = plot_df[plot_df.unique_id=='Airline1'].drop('unique_id', axis=1)\n",
    "plt.plot(plot_df['ds'], plot_df['y'], c='black', label='True')\n",
    "plt.plot(plot_df['ds'], plot_df['SOFTS'], c='blue', label='Forecast')\n",
    "ax.set_title('AirPassengers Forecast', fontsize=22)\n",
    "ax.set_ylabel('Monthly Passengers', fontsize=20)\n",
    "ax.set_xlabel('Year', fontsize=20)\n",
    "ax.legend(prop={'size': 15})\n",
    "ax.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Seed set to 1\n",
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "  | Name          | Type                   | Params\n",
      "---------------------------------------------------------\n",
      "0 | loss          | MSE                    | 0     \n",
      "1 | valid_loss    | MAE                    | 0     \n",
      "2 | padder        | ConstantPad1d          | 0     \n",
      "3 | scaler        | TemporalNorm           | 0     \n",
      "4 | enc_embedding | DataEmbedding_inverted | 6.4 K \n",
      "5 | encoder       | TransEncoder           | 725 K \n",
      "6 | projection    | Linear                 | 3.1 K \n",
      "---------------------------------------------------------\n",
      "735 K     Trainable params\n",
      "0         Non-trainable params\n",
      "735 K     Total params\n",
      "2.940     Total estimated model params size (MB)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fc391bd5ab3246c28fc569bce565e6aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Sanity Checking: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac970f4266ed477fb63ec9d14f13d2d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5f09d017599341f28379969e6eb40f43",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a7e9a9caf2fd4eddad28b3873154af94",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b740b3d3f492428f928457747ae75338",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cfc655cd46194fbba1f6890eaa421985",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Trainer already configured with model summary callbacks: [<class 'pytorch_lightning.callbacks.model_summary.ModelSummary'>]. Skipping setting a default `ModelSummary` callback.\n",
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ff3c35bdb4d94168a4da6a9b01aed199",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Predicting: |          | 0/? [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/marcopeix/miniconda3/envs/neuralforecast/lib/python3.10/site-packages/neuralforecast/core.py:201: FutureWarning: In a future version the predictions will have the id as a column. You can set the `NIXTLA_ID_AS_COL` environment variable to adopt the new behavior and to suppress this warning.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "#| eval: false\n",
    "\n",
    "Y_train_df = AirPassengersPanel[AirPassengersPanel.ds<AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 132 train\n",
    "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n",
    "\n",
    "model = SOFTS(h=12,\n",
    "              input_size=24,\n",
    "              n_series=1,\n",
    "              hidden_size=256,\n",
    "              d_core=256,\n",
    "              e_layers=2,\n",
    "              d_ff=64,\n",
    "              dropout=0.1,\n",
    "              use_norm=True,\n",
    "              loss=MSE(),\n",
    "              valid_loss=MAE(),\n",
    "              early_stop_patience_steps=3,\n",
    "              batch_size=32)\n",
    "\n",
    "fcst = NeuralForecast(models=[model], freq='M')\n",
    "fcst.fit(df=Y_train_df, val_size=12)\n",
    "forecasts = fcst.predict(futr_df=Y_test_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
